// utils/request.js

// 获取环境变量
const isDevelopment = process.env.NODE_ENV === 'development'; // 判断是否为开发环境

// 动态设置 baseURL
const baseURL = isDevelopment
  ? 'https://apis.netstart.cn/daodu' // 开发环境使用代理路径
  : 'https://haokan.chaihongjun.me/reverseproxy'; // 生产环境

// 创建请求实例
class Request {
  constructor() {
    this.baseURL = baseURL;
    this.timeout = 5000; // 超时时间（毫秒）
    this.headers = {
      'Content-Type': 'application/json'
    };
    this.retryOptions = {
      retries: 3, // 最多重试次数
      retryDelay: (retryCount) => (retryCount + 1) * 2000, // 延迟 2s/4s/6s
      shouldResetTimeout: true, // 每次重试都重新计时
      retryCondition: (error) => {
        // 1. 超时或网络断开
        if (error.errMsg && error.errMsg.includes('timeout')) return true;
        // 2. 仅重试服务器错误 (5xx)
        return error.statusCode >= 500;
      }
    };
    this.interceptors = {
      request: null,
      response: null
    };
  }

  // 配置请求拦截器
  useRequestInterceptor(interceptor) {
    this.interceptors.request = interceptor;
  }

  // 配置响应拦截器
  useResponseInterceptor(interceptor) {
    this.interceptors.response = interceptor;
  }

  // 格式化 GET 请求参数
  formatParams(params) {
    if (!params || Object.keys(params).length === 0) return '';
    const queryString = Object.entries(params)
      .map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(value)}`)
      .join('&');
    return `?${queryString}`;
  }

  // 通用请求方法
  request(options) {
    return new Promise((resolve, reject) => {
      let retryCount = 0;

      const attemptRequest = () => {
        // 请求拦截器
        if (this.interceptors.request) {
          options = this.interceptors.request(options);
        }

        uni.request({
          url: this.baseURL + options.url,
          method: options.method || 'GET',
          data: options.data || {},
          header: { ...this.headers, ...options.header },
          timeout: options.timeout || this.timeout,
          success: (res) => {
            // 响应拦截器
            if (this.interceptors.response) {
              res = this.interceptors.response(res);
            }

            if (res.statusCode === 200) {
              resolve(res.data); // 成功时返回数据
            } else {
              reject(new Error(`HTTP 错误：${res.statusCode}`)); // 失败时抛出错误
            }
          },
          fail: (err) => {
            if (
              retryCount < this.retryOptions.retries &&
              this.retryOptions.retryCondition(err)
            ) {
              retryCount++;
              setTimeout(attemptRequest, this.retryOptions.retryDelay(retryCount));
            } else {
              reject(new Error(`网络请求失败：${err.errMsg}`)); // 网络错误时抛出错误
            }
          }
        });
      };

      attemptRequest();
    });
  }

  // GET 请求
  get(url, params = {}, config = {}) {
    return this.request({
      url: `${url}${this.formatParams(params)}`,
      method: 'GET',
      ...config
    });
  }

  // POST 请求
  post(url, data = {}, config = {}) {
    return this.request({
      url,
      method: 'POST',
      data,
      ...config
    });
  }

  // PUT 请求
  put(url, data = {}, config = {}) {
    return this.request({
      url,
      method: 'PUT',
      data,
      ...config
    });
  }

  // DELETE 请求
  delete(url, params = {}, config = {}) {
    return this.request({
      url: `${url}${this.formatParams(params)}`,
      method: 'DELETE',
      ...config
    });
  }
}

// 创建实例
const instance = new Request();

// 配置请求拦截器（例如自动注入 Token）
instance.useRequestInterceptor((options) => {
  const token = uni.getStorageSync('token'); // 从本地存储中获取 Token
  if (token) {
    options.header = {
      ...options.header,
      Authorization: `Bearer ${token}`
    };
  }
  return options;
});

// 配置响应拦截器（例如统一处理错误码）
instance.useResponseInterceptor((res) => {
  if (res.statusCode === 401) {
    // 如果返回 401，表示未授权，跳转到登录页
    uni.showToast({
      title: '登录已过期，请重新登录',
      icon: 'none'
    });
    setTimeout(() => {
      uni.reLaunch({ url: '/pages/login/login' }); // 跳转到登录页面
    }, 1500);
  }
  return res;
});

// 导出实例
export default instance;